home *** CD-ROM | disk | FTP | other *** search
/ Delphi Magazine Collection 2001 / Delphi Magazine Collection 20001 (2001).iso / DISKS / ISSUE06 / STRINGS / STRC206.ZIP / TESTBED.PAS < prev   
Encoding:
Pascal/Delphi Source File  |  1995-12-22  |  61.4 KB  |  2,239 lines
  1. unit Testbed;
  2.  
  3. interface
  4.  
  5. uses
  6.  
  7.    SysUtils,
  8.    WinTypes,
  9.    WinProcs,
  10.    Messages,
  11.    Classes,
  12.    Graphics,
  13.    Controls,
  14.    Forms,
  15.    Dialogs,
  16.    StdCtrls,
  17.    ExtCtrls,
  18.    SafeStr,
  19.    StrClass,
  20.    ContainR, Console, Buttons;
  21.  
  22. type
  23.   TSCTestBed = class(TForm)
  24.     FuncLb    : TListbox;
  25.     GroupBox1 : TGroupBox;
  26.     Label4: TLabel;
  27.     Label2: TLabel;
  28.     Label3: TLabel;
  29.     procedure Button1Click(Sender: TObject);
  30.     procedure FormCreate(Sender: TObject);
  31.     procedure FormClose(Sender: TObject; var Action: TCloseAction);
  32.     procedure FuncLbClick(Sender: TObject);
  33.   private
  34.      TheFuncList : TRecordContainer;
  35.     { Private declarations }
  36.     PROCEDURE RunTest(fid : WORD);
  37.     PROCEDURE SetupFuncLb;
  38.   public
  39.     { Public declarations }
  40.     OutConsole: TConsole;
  41.   end;
  42.  
  43. var
  44.   SCTestBed: TSCTestBed;
  45.  
  46. implementation
  47.  
  48. {$R *.DFM}
  49.  
  50. { ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: }
  51.  
  52. CONST
  53.  
  54.    id_Create = 1;
  55.    id_CreateSize = 2;
  56.    id_CreateString =3;
  57.    id_CreateStringNL = 4;
  58.    id_CreateBoolean = 5;
  59.    id_Destroy = 6;
  60.    id_Copy = 7;
  61.    id_CopyFrom = 8;
  62.    id_Clear = 9;
  63.    id_Empty = 10;
  64.    id_Assign = 11;
  65.    id_AssignFrom = 12;
  66.    id_AssignLen = 13;
  67.    id_AssignMid = 14;
  68.    id_AssignNL = 15;
  69.    id_AssignPad = 16;
  70.    id_AssignRight = 17;
  71.    id_AssignTrim = 18;
  72.    id_Append = 19;
  73.    id_AppendBoolean = 20;
  74.    id_AppendByte = 21;
  75.    id_AppendCh = 22;
  76.    id_AppendDIC = 23;
  77.    id_AppendDouble = 24;
  78.    id_AppendDoubleTrim = 25;
  79.    id_AppendExt = 26;
  80.    id_AppendExtTrim = 27;
  81.    id_AppendLen = 28;
  82.    id_AppendLong = 29;
  83.    id_AppendMid = 30;
  84.    id_AppendNL = 31;
  85.    id_AppendPad = 32;
  86.    id_AppendPtr = 33;
  87.    id_AppendReal = 34;
  88.    id_AppendRight = 35;
  89.    id_AppendSIC = 36;
  90.    id_AppendTrim = 37;
  91.    id_AppendWithTab = 38;
  92.    id_NLAppend = 39;
  93.    id_Prepend = 40;
  94.    id_FirstNonSpaceCh = 41;
  95.    id_HasCh = 42;
  96.    id_isCh = 43;
  97.    id_IsFirstCh = 44;
  98.    id_IsLastCh = 45;
  99.    id_LastNonSpaceCh = 46;
  100.    id_RemoveLastCh = 47;
  101.    id_SetCh = 48;
  102.    id_FromBoolean = 49;
  103.    id_FromByte = 50;
  104.    id_FromChar = 51;
  105.    id_FromDouble = 52;
  106.    id_FromDoubleTrim = 53;
  107.    id_FromExt = 54;
  108.    id_FromExtTrim  = 55;
  109.    id_FromLong = 56;
  110.    id_FromPtr = 57;
  111.    id_FromReal = 58;
  112.    id_FromRealTrim = 59;
  113.    id_FromRGB = 60;
  114.    id_HexFromByte = 61;
  115.    id_HexFromLong = 62;
  116.    id_HexFromPtr = 63;
  117.    id_HexFromWord = 64;
  118.    id_ToBoolean = 65;
  119.    id_ToByte = 66;
  120.    id_ToChar = 67;
  121.    id_ToDouble = 68;
  122.    id_ToExt = 69;
  123.    id_ToInteger = 70;
  124.    id_ToLong = 71;
  125.    id_ToReal = 72;
  126.    id_ToRGB = 73;
  127.    id_ToWord = 74;
  128.    id_AppendStr = 75;
  129.    id_UpperCase = 76;
  130.    id_LowerCase = 77;
  131.    id_CompareStr = 78;
  132.    id_CompareText = 79;
  133.    id_AnsiUpperCase = 80;
  134.    id_AnsiLowerCase = 81;
  135.    id_AnsiCompareStr = 82;
  136.    id_AnsiCompareText = 83;
  137.    id_IsValidIdent = 84;
  138.    id_IntToStr = 85;
  139.    id_IntToHex = 86;
  140.    id_StrToInt = 87;
  141.    id_StrToIntDef = 88;
  142.    id_LoadStr = 89;
  143.    id_FmtLoadStr = 90;
  144.    id_Format = 91;
  145.    id_FloatToStr = 92;
  146.    id_FloatToStrF = 93;
  147.    id_FormatFloat = 94;
  148.    id_StrToFloat = 95;
  149.    id_StrCat = 96;
  150.    id_StrComp = 97;
  151.    id_StrCopy = 98;
  152.    id_StrECopy = 99;
  153.    id_StrEnd = 100;
  154.    id_StrIComp = 101;
  155.    id_StrLCat = 102;
  156.    id_StrLIComp = 103;
  157.    id_StrLComp = 104;
  158.    id_StrLCopy = 105;
  159.    id_StrLen = 106;
  160.    id_StrLower = 107;
  161.    id_StrMove = 108;
  162.    id_StrPas = 109;
  163.    id_StrPCopy = 110;
  164.    id_StrPos = 111;
  165.    id_StrRScan = 112;
  166.    id_StrScan = 113;
  167.    id_StrUpper = 114;
  168.    id_Compare = 115;
  169.    id_CompareI = 116;
  170.    id_CompareL = 117;
  171.    id_CompareLI = 118;
  172.    id_CompareLong = 119;
  173.    id_CompareDouble = 120;
  174.    id_CompareExt = 121;
  175.    id_IsSame = 122;
  176.    id_isSameL = 123;
  177.    id_IsSameLI = 124;
  178.    id_Includes = 125;
  179.    id_Within = 126;
  180.    id_Delete = 127;
  181.    id_Insert = 128;
  182.    id_InsertL = 129;
  183.    id_PadCentre = 130;
  184.    id_PadEnd = 131;
  185.    id_PadFront = 132;
  186.    id_RemoveDIC = 133;
  187.    id_RemoveSIC = 134;
  188.    id_Trim = 135;
  189.    id_TrimEnd = 136;
  190.    id_TrimFront = 137;
  191.    id_TrimZero = 138;
  192.    id_FindCmdLine = 139;
  193.    id_FindCmdLineAndParse = 140;
  194.    id_FindCmdLineParam = 141;
  195.    id_AppendStringRes = 142;
  196.    id_LoadStringRes = 143;
  197.    id_ReadIniKeyword = 144;
  198.    id_WriteIniKeyword = 145;
  199.    id_FindIniSectionKeywords = 146;
  200.    id_AddBackSlash = 147;
  201.    id_BuildPathName = 148;
  202.    id_DefaultExtension = 149;
  203.    id_ExpandFileName = 150;
  204.    id_ForceExtension = 151;
  205.    id_HasBackSlash = 152;
  206.    id_HasDrive = 153;
  207.    id_HasExtension = 154;
  208.    id_HasFileName = 155;
  209.    id_HasDirectory = 156;
  210.    id_DirectoryExists = 157;
  211.    id_DriveExists = 158;
  212.    id_FileExists = 159;
  213.    id_JustExtension = 160;
  214.    id_JustFileName = 161;
  215.    id_JustDirectory = 162;
  216.    id_SetCurDir = 163;
  217.    id_ChCount = 164;
  218.    id_FindBetween2Ch = 165;
  219.    id_FindFirst = 166;
  220.    id_FindFirstCh = 167;
  221.    id_FindLast = 168;
  222.    id_FindLastCh = 169;
  223.    id_FindNext = 170;
  224.    id_FindNextCh = 171;
  225.    id_FindPrev = 172;
  226.    id_FindPrevCh = 173;
  227.    id_SubStrCount = 174;
  228.    id_FirstCharToUpper = 175;
  229.    id_IsAlphaNumeric = 176;
  230.    id_ToLower = 177;
  231.    id_ToUpper = 178;
  232.    id_ReplaceAll = 179;
  233.    id_ReplaceFirst = 180;
  234.    id_ReplaceLast = 181;
  235.    id_ReplaceChAll = 182;
  236.    id_ReplaceChFirst = 183;
  237.    id_ReplaceChLast = 184;
  238.    id_FirstParseDelim = 185;
  239.    id_NextParseDelim = 186;
  240.    id_ParseDelimCount = 187;
  241.    id_ParseDelimToList = 188;
  242.    id_ParsePosToList = 189;
  243.    id_SameI          = 190;
  244.    id_JustName       = 191;
  245.    id_FileSplit      = 192;
  246.    id_FindCurrentDir = 193;
  247.    id_DeleteFrom     = 194;
  248.    id_FindRelPath    = 195;
  249.    id_ParseMultiDelimToList = 196;
  250.    id_Grep = 197;
  251.    id_AddFilterDesc = 198;
  252.    id_RecalcLength = 199;
  253.    id_NL = 200;
  254.    id_FromComponent = 201;
  255.    id_FromComponentItem = 202;
  256.    id_ToComponent = 203;
  257.    id_IsSameI = 204;
  258.    id_CreateDirectory = 205;
  259.    id_RemoveDirectory = 206;
  260.    id_SameDrive = 207;
  261.    id_SameDirectory = 208;
  262.    id_SameExtension = 209;
  263.    id_SameFileName = 210;
  264.    id_SameName = 211;
  265.  
  266. { ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: }
  267.  
  268. TYPE
  269.  
  270.    PFunctionRecord = ^TFunctionRecord;
  271.    TFunctionRecord = RECORD
  272.       Id   : WORD;
  273.       Name : PChar;
  274.    END;
  275.  
  276. { ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: }
  277.  
  278. procedure TSCTestBed.Button1Click(Sender: TObject);
  279. begin
  280.    Close;
  281. end;
  282.  
  283. { ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: }
  284.  
  285. procedure TSCTestBed.FormCreate(Sender: TObject);
  286. var
  287.    fno : integer;
  288. begin
  289.    { clear memo control }
  290.    OutConsole := TConsole.Create(Self);
  291.    OutConsole.Parent := GroupBox1;
  292.    OutConsole.Left := 8;
  293.    OutConsole.Top := 24;
  294.    OutConsole.Width := 569;
  295.    OutConsole.Height := 200;
  296.    OutConsole.Options := OutConsole.Options + [coStdOutput];
  297.    { create container to hold id/func name recs }
  298.    TheFuncList := TRecordContainer.Create(SIZEOF(TFunctionRecord));
  299.    SetupFuncLb;
  300.    FOR fno := 1 TO 211 DO
  301.       RunTest(fno);
  302.  
  303. end;
  304.  
  305. { ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: }
  306.  
  307. { ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: }
  308.  
  309. procedure TSCTestBed.FormClose(Sender: TObject; var Action: TCloseAction);
  310.  
  311.    { ++++++++++++++++++++++++++++++++++++++++++++++++++ }
  312.  
  313.    PROCEDURE KillStr(R : PFunctionRecord); FAR;
  314.    BEGIN
  315.       StrDispose(R^.Name);
  316.    END;
  317.  
  318.    { ++++++++++++++++++++++++++++++++++++++++++++++++++ }
  319.  
  320. begin
  321.    TheFuncList.ForEach(@KillStr);
  322.    TheFuncList.Free;
  323. end;
  324.  
  325. { ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: }
  326.  
  327. PROCEDURE TScTestbed.SetupFuncLb;
  328.  
  329.    { ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  330.  
  331.    PROCEDURE AddItem(id : INTEGER; AStr : PChar);
  332.    VAR
  333.       R : PFunctionRecord;
  334.    BEGIN
  335.       FuncLb.Items.Add(StrPas(AStr));
  336.       NEW(R);
  337.       R^.Id := id;
  338.       R^.Name := StrNew(AStr);
  339.       TheFuncList.Add(R);
  340.    END;
  341.  
  342.    { ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  343.  
  344. BEGIN
  345.    AddItem(id_Create,'Create');
  346.    AddItem(id_CreateSize,'CreateSize');
  347.    AddItem(id_CreateString,'CreateString');
  348.    AddItem(id_CreateStringNL,'CreateStringNL');
  349.    AddItem(id_CreateBoolean,'CreateBoolean');
  350.    AddItem(id_Destroy,'Destroy');
  351.    AddItem(id_Copy,'Copy');
  352.    AddItem(id_CopyFrom,'CopyFrom');
  353.    AddItem(id_Clear,'Clear');
  354.    AddItem(id_Empty,'Empty');
  355.    AddItem(id_RecalcLength,'RecalcLength');
  356.    AddItem(id_Assign,'Assign');
  357.    AddItem(id_AssignFrom,'AssignFrom');
  358.    AddItem(id_AssignLen,'AssignLen');
  359.    AddItem(id_AssignMid,'AssignMid');
  360.    AddItem(id_AssignNL,'AssignNL');
  361.    AddItem(id_AssignPad,'AssignPad');
  362.    AddItem(id_AssignRight,'AssignRight');
  363.    AddItem(id_AssignTrim,'AssignTrim');
  364.    AddItem(id_Append,'Append');
  365.    AddItem(id_AppendBoolean,'AppendBoolean');
  366.    AddItem(id_AppendByte,'AppendByte');
  367.    AddItem(id_AppendCh,'AppendCh');
  368.    AddItem(id_AppendDIC,'AppendDIC');
  369.    AddItem(id_AppendDouble,'AppendDouble');
  370.    AddItem(id_AppendDoubleTrim,'AppendDoubleTrim');
  371.    AddItem(id_AppendExt,'AppendExt');
  372.    AddItem(id_AppendExtTrim,'AppendExtTrim');
  373.    AddItem(id_AppendLen,'AppendLen');
  374.    AddItem(id_AppendLong,'AppendLong');
  375.    AddItem(id_AppendMid,'AppendMid');
  376.    AddItem(id_AppendNL,'AppendNL');
  377.    AddItem(id_AppendPad,'AppendPad');
  378.    AddItem(id_AppendPtr,'AppendPtr');
  379.    AddItem(id_AppendReal,'AppendReal');
  380.    AddItem(id_AppendRight,'AppendRight');
  381.    AddItem(id_AppendSIC,'AppendSIC');
  382.    AddItem(id_AppendTrim,'AppendTrim');
  383.    AddItem(id_AppendWithTab,'AppendWithTab');
  384.    AddItem(id_NL,'NL');
  385.    AddItem(id_NLAppend,'NLAppend');
  386.    AddItem(id_Prepend,'Prepend');
  387.    AddItem(id_FirstNonSpaceCh,'FirstNonSpaceCh');
  388.    AddItem(id_HasCh,'HasCh');
  389.    AddItem(id_isCh,'IsCh');
  390.    AddItem(id_IsFirstCh,'IsFirstCh');
  391.    AddItem(id_IsLastCh,'IsLastCh');
  392.    AddItem(id_LastNonSpaceCh,'LastNonSpaceCh');
  393.    AddItem(id_RemoveLastCh,'RemoveLastCh');
  394.    AddItem(id_SetCh,'SetCh');
  395.    AddItem(id_FromBoolean,'FromBoolean');
  396.    AddItem(id_FromByte,'FromByte');
  397.    AddItem(id_FromChar,'FromChar');
  398.    AddItem(id_FromComponent,'FromComponent');
  399.    AddItem(id_FromComponentItem,'FromComponentItem');
  400.    AddItem(id_FromDouble,'FromDouble');
  401.    AddItem(id_FromDoubleTrim,'FromDoubleTrim');
  402.    AddItem(id_FromExt,'FromExt');
  403.    AddItem(id_FromExtTrim,'FromExtTrim');
  404.    AddItem(id_FromLong,'FromLong');
  405.    AddItem(id_FromPtr,'FromPtr');
  406.    AddItem(id_FromReal,'FromReal');
  407.    AddItem(id_FromRealTrim,'FromRealTrim');
  408.    AddItem(id_FromRGB,'FromRGB');
  409.    AddItem(id_HexFromByte,'HexFromByte');
  410.    AddItem(id_HexFromLong,'HexFromLong');
  411.    AddItem(id_HexFromPtr,'HexFromPtr');
  412.    AddItem(id_HexFromWord,'HexFromWord');
  413.    AddItem(id_ToBoolean,'ToBoolean');
  414.    AddItem(id_ToByte,'ToByte');
  415.    AddItem(id_ToChar,'ToChar');
  416.    AddItem(id_ToComponent,'ToComponent');
  417.    AddItem(id_ToDouble,'ToDouble');
  418.    AddItem(id_ToExt,'ToExt');
  419.    AddItem(id_ToInteger,'ToInteger');
  420.    AddItem(id_ToLong,'ToLong');
  421.    AddItem(id_ToReal,'ToReal');
  422.    AddItem(id_ToRGB,'ToRGB');
  423.    AddItem(id_ToWord,'ToWord');
  424.    AddItem(id_AppendStr,'AppendStr');
  425.    AddItem(id_UpperCase,'UpperCase');
  426.    AddItem(id_LowerCase,'LowerCase');
  427.    AddItem(id_CompareStr,'CompareStr');
  428.    AddItem(id_CompareText,'CompareText');
  429.    AddItem(id_AnsiUpperCase,'AnsiUpperCase');
  430.    AddItem(id_AnsiLowerCase,'AnsiLowerCase');
  431.    AddItem(id_AnsiCompareStr,'AnsiCompareStr');
  432.    AddItem(id_AnsiCompareText,'AnsiCompareText');
  433.    AddItem(id_IsValidIdent,'IsValidIdent');
  434.    AddItem(id_IntToStr,'IntToStr');
  435.    AddItem(id_IntToHex,'IntToHex');
  436.    AddItem(id_StrToInt,'StrToInt');
  437.    AddItem(id_StrToIntDef,'StrToIntDef');
  438.    AddItem(id_LoadStr,'LoadStr');
  439.    AddItem(id_FmtLoadStr,'FmtLoadStr');
  440.    AddItem(id_Format,'Format');
  441.    AddItem(id_FloatToStr,'FloatToStr');
  442.    AddItem(id_FloatToStrF,'FloatToStrF');
  443.    AddItem(id_FormatFloat,'FormatFloat');
  444.    AddItem(id_StrToFloat,'StrToFloat');
  445.    AddItem(id_StrCat,'StrCat');
  446.    AddItem(id_StrComp,'StrComp');
  447.    AddItem(id_StrCopy,'StrCopy');
  448.    AddItem(id_StrECopy,'StrECopy');
  449.    AddItem(id_StrEnd,'StrEnd');
  450.    AddItem(id_StrIComp,'StrIComp');
  451.    AddItem(id_StrLCat,'StrLCat');
  452.    AddItem(id_StrLIComp,'StrLIComp');
  453.    AddItem(id_StrLComp,'StrLComp');
  454.    AddItem(id_StrLCopy,'StrLCopy');
  455.    AddItem(id_StrLen,'StrLen');
  456.    AddItem(id_StrLower,'StrLower');
  457.    AddItem(id_StrMove,'StrMove');
  458.    AddItem(id_StrPas,'StrPas');
  459.    AddItem(id_StrPCopy,'StrPCopy');
  460.    AddItem(id_StrPos,'StrPos');
  461.    AddItem(id_StrRScan,'StrRScan');
  462.    AddItem(id_StrScan,'StrScan');
  463.    AddItem(id_StrUpper,'StrUpper');
  464.    AddItem(id_Compare,'Compare');
  465.    AddItem(id_CompareI,'CompareI');
  466.    AddItem(id_CompareL,'CompareL');
  467.    AddItem(id_CompareLI,'CompareLI');
  468.    AddItem(id_CompareLong,'CompareLong');
  469.    AddItem(id_CompareDouble,'CompareDouble');
  470.    AddItem(id_CompareExt,'CompareExt');
  471.    AddItem(id_IsSame,'IsSame');
  472.    AddItem(id_IsSameI,'IsSameI');
  473.    AddItem(id_isSameL,'IsSameL');
  474.    AddItem(id_IsSameLI,'IsSameLI');
  475.    AddItem(id_Includes,'Includes');
  476.    AddItem(id_Within,'Within');
  477.    AddItem(id_Delete,'Delete');
  478.    AddItem(id_DeleteFrom,'DeleteFrom');
  479.    AddItem(id_Insert,'Insert');
  480.    AddItem(id_InsertL,'InsertL');
  481.    AddItem(id_PadCentre,'PadCentre');
  482.    AddItem(id_PadEnd,'PadEnd');
  483.    AddItem(id_PadFront,'PadFront');
  484.    AddItem(id_RemoveDIC,'RemoveDIC');
  485.    AddItem(id_RemoveSIC,'RemoveSIC');
  486.    AddItem(id_Trim,'Trim');
  487.    AddItem(id_TrimEnd,'TrimEnd');
  488.    AddItem(id_TrimFront,'TrimFront');
  489.    AddItem(id_TrimZero,'TrimZero');
  490.    AddItem(id_FindCmdLine,'FindCmdLine');
  491.    AddItem(id_FindCmdLineAndParse,'FindCmdLineAndParse');
  492.    AddItem(id_FindCmdLineParam,'FindCmdLineParam');
  493.    AddItem(id_AppendStringRes,'AppendStringRes');
  494.    AddItem(id_LoadStringRes,'LoadStringRes');
  495.    AddItem(id_ReadIniKeyword,'ReadIniKeyword');
  496.    AddItem(id_WriteIniKeyword,'WriteIniKeyword');
  497.    AddItem(id_FindIniSectionKeywords,'FindIniSectionKeywords');
  498.    AddItem(id_AddBackSlash,'AddBackSlash');
  499.    AddItem(id_AddFilterDesc,'AddFilterDesc');
  500.    AddItem(id_BuildPathName,'BuildPathName');
  501.    AddItem(id_CreateDirectory,'CreateDirectory');
  502.    AddItem(id_DefaultExtension,'DefaultExtension');
  503.    AddItem(id_DirectoryExists,'DirectoryExists');
  504.    AddItem(id_DriveExists,'DriveExists');
  505.    AddItem(id_ExpandFileName,'ExpandFileName');
  506.    AddItem(id_FileExists,'FileExists');
  507.    AddItem(id_FindCurrentDir,'FindCurrentDir');
  508.    AddItem(id_FindRelPath,'FindRelPath');
  509.    AddItem(id_ForceExtension,'ForceExtension');
  510.    AddItem(id_HasBackSlash,'HasBackSlash');
  511.    AddItem(id_HasDrive,'HasDrive');
  512.    AddItem(id_HasExtension,'HasExtension');
  513.    AddItem(id_HasFileName,'HasFileName');
  514.    AddItem(id_HasDirectory,'HasDirectory');
  515.    AddItem(id_FileSplit,'FileSplit');
  516.    AddItem(id_JustExtension,'JustExtension');
  517.    AddItem(id_JustFileName,'JustFileName');
  518.    AddItem(id_JustName,'JustName');
  519.    AddItem(id_JustDirectory,'JustDirectory');
  520.    AddItem(id_RemoveDirectory,'RemoveDirectory');
  521.    AddItem(id_SameDrive,'SameDrive');
  522.    AddItem(id_SameDirectory,'SameDirectory');
  523.    AddItem(id_SameExtension,'SameExtension');
  524.    AddItem(id_SameFileName,'SameFileName');
  525.    AddItem(id_SameName,'SameName');
  526.    AddItem(id_SetCurDir,'SetCurDir');
  527.    AddItem(id_ChCount,'ChCount');
  528.    AddItem(id_FindBetween2Ch,'FindBetween2Ch');
  529.    AddItem(id_FindFirst,'FindFirst');
  530.    AddItem(id_FindFirstCh,'FindFirstCh');
  531.    AddItem(id_FindLast,'FindLast');
  532.    AddItem(id_FindLastCh,'FindLastCh');
  533.    AddItem(id_FindNext,'FindNext');
  534.    AddItem(id_FindNextCh,'FindNextCh');
  535.    AddItem(id_FindPrev,'FindPrev');
  536.    AddItem(id_FindPrevCh,'FindPrevCh');
  537.    AddItem(id_Grep,'Grep');
  538.    AddItem(id_SubStrCount,'SubStrCount');
  539.    AddItem(id_FirstCharToUpper,'FirstCharToUpper');
  540.    AddItem(id_IsAlphaNumeric,'IsAlphaNumeric');
  541.    AddItem(id_ToLower,'ToLower');
  542.    AddItem(id_ToUpper,'ToUpper');
  543.    AddItem(id_ReplaceAll,'ReplaceAll');
  544.    AddItem(id_ReplaceFirst,'ReplaceFirst');
  545.    AddItem(id_ReplaceLast,'ReplaceLast');
  546.    AddItem(id_ReplaceChAll,'ReplaceChAll');
  547.    AddItem(id_ReplaceChFirst,'ReplaceChFirst');
  548.    AddItem(id_ReplaceChLast,'ReplaceChLast');
  549.    AddItem(id_FirstParseDelim,'FirstParseDelim');
  550.    AddItem(id_NextParseDelim,'NextParseDelim');
  551.    AddItem(id_ParseDelimCount,'ParseDelimCount');
  552.    AddItem(id_ParseDelimToList,'ParseDelimToList');
  553.    AddItem(id_ParseMultiDelimToList,'ParseMultiDelimToList');
  554.    AddItem(id_ParsePosToList,'ParsePosToList');
  555.    FuncLb.ItemIndex := -1;
  556. END;
  557.  
  558. { ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: }
  559.  
  560. procedure TSCTestBed.FuncLbClick(Sender: TObject);
  561. CONST
  562.    MaxLen = 500;
  563. VAR
  564.    AStr : PChar;
  565.    AnItem : PFunctionRecord;
  566.  
  567.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  568.  
  569.    FUNCTION MatchStr(R : PFunctionRecord) : BOOLEAN; FAR;
  570.    BEGIN
  571.       MatchStr := (SafeStrIComp(AStr,R^.Name) = 0);
  572.    END;
  573.  
  574.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  575.  
  576. begin
  577.    GetMem(AStr,Maxlen);
  578.    StrPCopy(AStr,FuncLb.Items.Strings[FuncLb.ItemIndex]);
  579.    AnItem := TheFuncList.FirstThat(@MatchStr);
  580.    IF AnItem <> NIL THEN
  581.       RunTest(AnItem^.Id);
  582.    FreeMem(AStr,Maxlen);
  583.  
  584. end;
  585.  
  586. { ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: }
  587.  
  588. PROCEDURE TScTestBed.RunTest(fid : WORD);
  589. CONST
  590.    ANullPChar : PChar = NIL;
  591.    APChar : PChar = 'PChar string';
  592.    AStr : STRING = 'Pascal string';
  593.    ANullStr : STRING = '';
  594.    ALong : LONGINT = 99000;
  595.    APath : STRING = 'c:\windows\system.ini';
  596.    AReal : REAL = 21.3;
  597.    AnInteger : INTEGER = -5;
  598.    AWord : WORD = 66;
  599.    ADouble : DOUBLE = 66.4;
  600.    AByte : BYTE = 124;
  601.    AnExt : EXTENDED = 134.456;
  602.  
  603. VAR
  604.    ANullStrObj,AStrObj : TStringClass;
  605.  
  606.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  607.  
  608.    PROCEDURE DoCreate;
  609.    BEGIN
  610.       Writeln('Instantiates an object with null string and zero buffer length');
  611.       Writeln('e.g. AStrObj := TStringClass.Create');
  612.    END;
  613.  
  614.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  615.  
  616.    PROCEDURE DoCreateSize;
  617.    BEGIN
  618.       Writeln('Instantiates an object with a null string but with a buffer');
  619.       Writeln(' size preset to ''ASize'' bytes. Useful for situations ');
  620.       Writeln('where lots of assigns/appends are anticipated.');
  621.       Writeln('e.g. AStrObj := TStringClass.CreateSize(2000)');
  622.    END;
  623.  
  624.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  625.  
  626.    PROCEDURE DoCreateString;
  627.    VAR
  628.       TObj : TStringClass;
  629.    BEGIN
  630.       Writeln('Code:');
  631.       Writeln('TObj := TStringClass.CreateString([AStr,''.'',APChar,''.'',ANullPChar,''.'']);');
  632.       TObj := TStringClass.CreateString([AStr,'.',APChar,'.',ANullPChar,'.']);
  633.       Writeln;
  634.       Writeln('Result:');
  635.       Writeln(TObj.ZString);
  636.       TObj.Free;
  637.    END;
  638.  
  639.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  640.  
  641.    PROCEDURE DoCreateStringNL;
  642.    VAR
  643.       TObj : TStringClass;
  644.    BEGIN
  645.       Writeln('Code:');
  646.       Writeln('TObj := TStringClass.CreateStringNL([AStr]);');
  647.       Writeln('TObj.Append([APChar]);');
  648.       TObj := TStringClass.CreateStringNL([AStr]);
  649.       TObj.Append([APChar]);
  650.       Writeln;
  651.       Writeln('Result:');
  652.       Writeln(TObj.ZString);
  653.       TObj.Free;
  654.    END;
  655.  
  656.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  657.  
  658.    PROCEDURE DoCreateBoolean;
  659.    VAR
  660.       TObj : TStringClass;
  661.    BEGIN
  662.       Writeln('Code:');
  663.       Writeln('TObj := TStringClass.CreateBoolean(TRUE,bt_NoYes);');
  664.       TObj := TStringClass.CreateBoolean(TRUE,bt_NoYes);
  665.       Writeln;
  666.       Writeln('Result:');
  667.       Writeln(TObj.ZString);
  668.       TObj.Free;
  669.    END;
  670.  
  671.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  672.  
  673.    PROCEDURE DoDestroy;
  674.    BEGIN
  675.       Writeln('Disposes the string class object.');
  676.       Writeln('Do not call directly. Use the Free metheod');
  677.    END;
  678.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  679.  
  680.    PROCEDURE DoCopy;
  681.    VAR
  682.       TObj,CObj : TStringClass;
  683.    BEGIN
  684.       Writeln('Code:');
  685.       Writeln('TObj := TStringClass.CreateString([AStr]);');
  686.       Writeln('CObj := TObj.Copy;');
  687.       TObj := TStringClass.CreateString([AStr]);
  688.       CObj := TObj.Copy;
  689.       Writeln;
  690.       Writeln('Result:');
  691.       Writeln('Original string object text = ',TObj.ZString);
  692.       Writeln('Copy string object text     = ',CObj.ZString);
  693.       TObj.Free;
  694.       CObj.Free;
  695.    END;
  696.  
  697.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  698.  
  699.    PROCEDURE DoCopyFrom;
  700.    VAR
  701.       TObj,CObj : TStringClass;
  702.    BEGIN
  703.       Writeln('Code:');
  704.       Writeln('TObj := TStringClass.CreateString([AStr]);');
  705.       Writeln('CObj := TStringClass.Create;');
  706.       Writeln('CObj.CopyFrom(TObj);');
  707.       TObj := TStringClass.CreateString([AStr]);
  708.       CObj := TStringClass.Create;
  709.       CObj.CopyFrom(TObj);
  710.       Writeln;
  711.       Writeln('Result:');
  712.       Writeln('Original string object text = ',TObj.ZString);
  713.       Writeln('Copy string object text     = ',CObj.ZString);
  714.       TObj.Free;
  715.       CObj.Free;
  716.    END;
  717.  
  718.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  719.  
  720.    PROCEDURE DoClear;
  721.    VAR
  722.       TObj : TStringClass;
  723.    BEGIN
  724.       Writeln('Code:');
  725.       Writeln('TObj := TStringClass.CreateString([AStr]);');
  726.       Writeln('TObj.Clear;');
  727.       TObj := TStringClass.CreateString([AStr]);
  728.       Writeln;
  729.       Writeln('Result pre clear :');
  730.       Writeln(TObj.ZString,'(Buffer Size = ',TObj.MaxSize,')');
  731.       TObj.Clear;
  732.       Writeln;
  733.       Writeln('Result post clear :');
  734.       Writeln(TObj.ZString,'(Buffer Size = ',TObj.MaxSize,')');
  735.       Writeln;
  736.       TObj.Free;
  737.    END;
  738.  
  739.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  740.  
  741.    PROCEDURE DoEmpty;
  742.    VAR
  743.       TObj : TStringClass;
  744.    BEGIN
  745.       Writeln('Code:');
  746.       Writeln('TObj := TStringClass.CreateString([AStr]);');
  747.       Writeln('TObj.Empty;');
  748.       TObj := TStringClass.CreateString([AStr]);
  749.       Writeln;
  750.       Writeln('Result pre Empty :');
  751.       Writeln(TObj.ZString,'(Buffer Size = ',TObj.MaxSize,')');
  752.       TObj.Empty;
  753.       Writeln;
  754.       Writeln('Result post Empty :');
  755.       Writeln(TObj.ZString,'(Buffer Size = ',TObj.MaxSize,')');
  756.       Writeln;
  757.       TObj.Free;
  758.    END;
  759.  
  760.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  761.  
  762.    PROCEDURE DoAssign;
  763.    VAR
  764.       TObj : TStringClass;
  765.    BEGIN
  766.       Writeln('Code:');
  767.       Writeln('TObj := TStringClass.Create;');
  768.       Writeln('TObj.Assign([AStr,'' and '',APChar,'' '',ALong]);');
  769.       TObj := TStringClass.Create;
  770.       TObj.Assign([AStr,' and ',APChar,' ',ALong]);
  771.       Writeln;
  772.       Writeln('Result:');
  773.       Writeln(TObj.ZString);
  774.       TObj.Free;
  775.    END;
  776.  
  777.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  778.  
  779.    PROCEDURE DoAssignFrom;
  780.    VAR
  781.       TObj : TStringClass;
  782.    BEGIN
  783.       Writeln('Code:');
  784.       Writeln('TObj := TStringClass.Create;');
  785.       Writeln('TObj.AssignFrom([AStr,'' and '',APChar,'' '',ALong],7);');
  786.       TObj := TStringClass.Create;
  787.       TObj.AssignFrom([AStr,' and ',APChar,' ',ALong],7);
  788.       Writeln;
  789.       Writeln('Result:');
  790.       Writeln(TObj.ZString);
  791.       TObj.Free;
  792.    END;
  793.  
  794.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  795.  
  796.    PROCEDURE DoAssignLen;
  797.    VAR
  798.       TObj : TStringClass;
  799.    BEGIN
  800.       Writeln('Code:');
  801.       Writeln('TObj := TStringClass.Create;');
  802.       Writeln('TObj.AssignLen([AStr,'' and '',APChar,'' '',ALong],9);');
  803.       TObj := TStringClass.Create;
  804.       TObj.AssignLen([AStr,' and ',APChar,' ',ALong],9);
  805.       Writeln;
  806.       Writeln('Result:');
  807.       Writeln(TObj.ZString);
  808.       TObj.Free;
  809.    END;
  810.  
  811.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  812.  
  813.    PROCEDURE DoAssignMid;
  814.    VAR
  815.       TObj : TStringClass;
  816.    BEGIN
  817.       Writeln('Code:');
  818.       Writeln('TObj := TStringClass.Create;');
  819.       Writeln('TObj.AssignMid([AStr,'' and '',APChar,'' '',ALong],7,5);');
  820.       TObj := TStringClass.Create;
  821.       TObj.AssignMid([AStr,' and ',APChar,' ',ALong],7,5);
  822.       Writeln;
  823.       Writeln('Result:');
  824.       Writeln(TObj.ZString);
  825.       TObj.Free;
  826.    END;
  827.  
  828.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  829.  
  830.    PROCEDURE DoAssignNL;
  831.    VAR
  832.       TObj : TStringClass;
  833.    BEGIN
  834.       Writeln('Code:');
  835.       Writeln('TObj := TStringClass.Create;');
  836.       Writeln('TObj.AssignNL([AStr,'' and '',APChar,'' '',ALong]);');
  837.       Writeln('TObj.Append([AWord]);');
  838.       TObj := TStringClass.Create;
  839.       TObj.AssignNL([AStr,' and ',APChar,' ',ALong]);
  840.       TObj.Append([AWord]);
  841.       Writeln;
  842.       Writeln('Result:');
  843.       Writeln(TObj.ZString);
  844.       TObj.Free;
  845.    END;
  846.  
  847.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  848.  
  849.    PROCEDURE DoAssignPad;
  850.    VAR
  851.       TObj : TStringClass;
  852.    BEGIN
  853.       Writeln('Code:');
  854.       Writeln('TObj := TStringClass.Create;');
  855.       Writeln('TObj.AssignPad([AStr],15,''x'');');
  856.       TObj := TStringClass.Create;
  857.       TObj.AssignPad([AStr],15,'x');
  858.       Writeln;
  859.       Writeln('Result:');
  860.       Writeln(TObj.ZString);
  861.       TObj.Free;
  862.    END;
  863.  
  864.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  865.  
  866.    PROCEDURE DoAssignRight;
  867.    VAR
  868.       TObj : TStringClass;
  869.    BEGIN
  870.       Writeln('Code:');
  871.       Writeln('TObj := TStringClass.Create;');
  872.       Writeln('TObj.AssignRight([AStr],3);');
  873.       TObj := TStringClass.Create;
  874.       TObj.AssignRight([AStr],3);
  875.       Writeln;
  876.       Writeln('Result:');
  877.       Writeln(TObj.ZString);
  878.       TObj.Free;
  879.    END;
  880.  
  881.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  882.  
  883.    PROCEDURE DoAssignTrim;
  884.    VAR
  885.       TObj : TStringClass;
  886.    BEGIN
  887.       Writeln('Code:');
  888.       Writeln('TObj := TStringClass.Create;');
  889.       Writeln('TObj.AssignTrim([''    '',AStr,''   '']);');
  890.       TObj := TStringClass.Create;
  891.       TObj.AssignTrim(['    ',AStr,'   ']);
  892.       Writeln;
  893.       Writeln('Result:');
  894.       Writeln(TObj.ZString);
  895.       TObj.Free;
  896.    END;
  897.  
  898.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  899.  
  900.    PROCEDURE DoAppend;
  901.    VAR
  902.       TObj : TStringClass;
  903.    BEGIN
  904.       Writeln('Code:');
  905.       Writeln('TObj := TStringClass.CreateString([AStr]);');
  906.       Writeln('TObj.Append([APChar,'' '',ADouble]);');
  907.       TObj := TStringClass.CreateString([AStr]);
  908.       TObj.Append([APChar,' ',ADouble]);
  909.       Writeln;
  910.       Writeln('Result:');
  911.       Writeln;
  912.       Writeln(TObj.ZString);
  913.       TObj.Free;
  914.    END;
  915.  
  916.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  917.  
  918.    PROCEDURE DoAppendBoolean;
  919.    VAR
  920.       TObj : TStringClass;
  921.    BEGIN
  922.       Writeln('Code:');
  923.       Writeln('TObj := TStringClass.CreateString([AStr,'' = '']);');
  924.       Writeln('TObj.AppendBoolean(FALSE,bt_FalseTrue);');
  925.       TObj := TStringClass.CreateString([AStr,' = ']);
  926.       TObj.AppendBoolean(FALSE,bt_FalseTrue);
  927.       Writeln;
  928.       Writeln('Result:');
  929.       Writeln(TObj.ZString);
  930.       TObj.Free;
  931.    END;
  932.  
  933.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  934.  
  935.    PROCEDURE DoAppendByte;
  936.    VAR
  937.       TObj : TStringClass;
  938.    BEGIN
  939.       Writeln('Code:');
  940.       Writeln('TObj := TStringClass.CreateString([AStr,'' = '']);');
  941.       Writeln('TObj.AppendByte(AByte);');
  942.       TObj := TStringClass.CreateString([AStr,' = ']);
  943.       TObj.AppendByte(AByte);
  944.       Writeln;
  945.       Writeln('Result:');
  946.       Writeln(TObj.ZString);
  947.       TObj.Free;
  948.    END;
  949.  
  950.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  951.  
  952.    PROCEDURE DoAppendCh;
  953.    VAR
  954.       TObj : TStringClass;
  955.    BEGIN
  956.       Writeln('Code:');
  957.       Writeln('TObj := TStringClass.CreateString([AStr]);');
  958.       Writeln('TObj.AppendCh(''*'');');
  959.       TObj := TStringClass.CreateString([AStr]);
  960.       TObj.AppendCh('*');
  961.       Writeln;
  962.       Writeln('Result:');
  963.       Writeln(TObj.ZString);
  964.       TObj.Free;
  965.    END;
  966.  
  967.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  968.  
  969.    PROCEDURE DoAppendDIC;
  970.    VAR
  971.       TObj : TStringClass;
  972.    BEGIN
  973.       Writeln('Code:');
  974.       Writeln('TObj := TStringClass.CreateString([''Call me '']);');
  975.       Writeln('TObj.AppendDIC([''Mr Tibbs'']);');
  976.       TObj := TStringClass.CreateString(['Call me ']);
  977.       TObj.AppendDIC(['Mr Tibbs']);
  978.       Writeln;
  979.       Writeln('Result:');
  980.       Writeln(TObj.ZString);
  981.       TObj.Free;
  982.    END;
  983.  
  984.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  985.  
  986.    PROCEDURE DoAppendDouble;
  987.    VAR
  988.       TObj : TStringClass;
  989.    BEGIN
  990.       Writeln('Code:');
  991.       Writeln('TObj := TStringClass.CreateString([''Value =  '']);');
  992.       Writeln('TObj.AppendDouble(ADouble,10,3);');
  993.       TObj := TStringClass.CreateString(['Value =  ']);
  994.       TObj.AppendDouble(ADouble,10,3);
  995.       Writeln;
  996.       Writeln('Result:');
  997.       Writeln(TObj.ZString);
  998.       TObj.Free;
  999.    END;
  1000.  
  1001.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1002.  
  1003.    PROCEDURE DoAppendDoubleTrim;
  1004.    VAR
  1005.       TObj : TStringClass;
  1006.    BEGIN
  1007.       Writeln('Code:');
  1008.       Writeln('TObj := TStringClass.CreateString([''Value =  '']);');
  1009.       Writeln('TObj.AppendDoubleTrim(ADouble);');
  1010.       TObj := TStringClass.CreateString(['Value =  ']);
  1011.       TObj.AppendDoubleTrim(ADouble);
  1012.       Writeln;
  1013.       Writeln('Result:');
  1014.       Writeln(TObj.ZString);
  1015.       TObj.Free;
  1016.    END;
  1017.  
  1018.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1019.  
  1020.    PROCEDURE DoAppendExt;
  1021.    VAR
  1022.       TObj : TStringClass;
  1023.    BEGIN
  1024.       Writeln('Code:');
  1025.       Writeln('TObj := TStringClass.CreateString([''Value =  '']);');
  1026.       Writeln('TObj.AppendExt(AnExt,10,3);');
  1027.       TObj := TStringClass.CreateString(['Value =  ']);
  1028.       TObj.AppendExt(AnExt,10,3);
  1029.       Writeln;
  1030.       Writeln('Result:');
  1031.       Writeln(TObj.ZString);
  1032.       TObj.Free;
  1033.    END;
  1034.  
  1035.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1036.  
  1037.    PROCEDURE DoAppendExtTrim;
  1038.    VAR
  1039.       TObj : TStringClass;
  1040.    BEGIN
  1041.       Writeln('Code:');
  1042.       Writeln('TObj := TStringClass.CreateString([''Value =  '']);');
  1043.       Writeln('TObj.AppendExtTrim(AnExt);');
  1044.       TObj := TStringClass.CreateString(['Value =  ']);
  1045.       TObj.AppendExtTrim(AnExt);
  1046.       Writeln;
  1047.       Writeln('Result:');
  1048.       Writeln(TObj.ZString);
  1049.       TObj.Free;
  1050.    END;
  1051.  
  1052.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1053.  
  1054.    PROCEDURE DoAppendLen;
  1055.    VAR
  1056.       TObj : TStringClass;
  1057.    BEGIN
  1058.       Writeln('Code:');
  1059.       Writeln('TObj := TStringClass.CreateString([AStr]);');
  1060.       Writeln('TObj.AppendLen([APChar],4);');
  1061.       TObj := TStringClass.CreateString([AStr]);
  1062.       TObj.AppendLen([APChar],4);
  1063.       Writeln;
  1064.       Writeln('Result:');
  1065.       Writeln(TObj.ZString);
  1066.       TObj.Free;
  1067.    END;
  1068.  
  1069.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1070.  
  1071.    PROCEDURE DoAppendLong;
  1072.    VAR
  1073.       TObj : TStringClass;
  1074.    BEGIN
  1075.       Writeln('Code:');
  1076.       Writeln('TObj := TStringClass.CreateString([AStr]);');
  1077.       Writeln('TObj.AppendLong(ALong);');
  1078.       TObj := TStringClass.CreateString([AStr]);
  1079.       TObj.AppendLong(ALong);
  1080.       Writeln;
  1081.       Writeln('Result:');
  1082.       Writeln(TObj.ZString);
  1083.       TObj.Free;
  1084.    END;
  1085.  
  1086.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1087.  
  1088.    PROCEDURE DoAppendMid;
  1089.    VAR
  1090.       TObj : TStringClass;
  1091.    BEGIN
  1092.       Writeln('Code:');
  1093.       Writeln('TObj := TStringClass.CreateString([AStr]);');
  1094.       Writeln('TObj.AppendMid([APChar],3,2);');
  1095.       TObj := TStringClass.CreateString([AStr]);
  1096.       TObj.AppendMid([APChar],3,2);
  1097.       Writeln;
  1098.       Writeln('Result:');
  1099.       Writeln(TObj.ZString);
  1100.       TObj.Free;
  1101.    END;
  1102.  
  1103.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1104.  
  1105.    PROCEDURE DoAppendNL;
  1106.    VAR
  1107.       TObj : TStringClass;
  1108.    BEGIN
  1109.       Writeln('Code:');
  1110.       Writeln('TObj := TStringClass.Create;');
  1111.       Writeln('TObj.AppendNL([''1st line'']);');
  1112.       Writeln('TObj.Append([''2nd line'']);');
  1113.       TObj := TStringClass.Create;
  1114.       TObj.AppendNL(['1st line']);
  1115.       TObj.Append(['2nd line']);
  1116.       Writeln;
  1117.       Writeln('Result:');
  1118.       Writeln(TObj.ZString);
  1119.       TObj.Free;
  1120.    END;
  1121.  
  1122.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1123.  
  1124.    PROCEDURE DoAppendPad;
  1125.    VAR
  1126.       TObj : TStringClass;
  1127.    BEGIN
  1128.       Writeln('Code:');
  1129.       Writeln('TObj := TStringClass.CreateString([AStr]);');
  1130.       Writeln('TObj.AppendPad([APChar],30,''?'');');
  1131.       TObj := TStringClass.CreateString([AStr]);
  1132.       TObj.AppendPad([APChar],30,'?');
  1133.       Writeln;
  1134.       Writeln('Result:');
  1135.       Writeln(TObj.ZString);
  1136.       TObj.Free;
  1137.    END;
  1138.  
  1139.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1140.  
  1141.    PROCEDURE DoAppendPtr;
  1142.    VAR
  1143.       TObj : TStringClass;
  1144.    BEGIN
  1145.       Writeln('Code:');
  1146.       Writeln('TObj := TStringClass.CreateString([''ALong Pointer = '']);');
  1147.       Writeln('TObj.AppendPtr(@ALong);');
  1148.       TObj := TStringClass.CreateString(['ALong Pointer = ']);
  1149.       TObj.AppendPtr(@ALong);
  1150.       Writeln;
  1151.       Writeln('Result:');
  1152.       Writeln(TObj.ZString);
  1153.       TObj.Free;
  1154.    END;
  1155.  
  1156.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1157.  
  1158.    PROCEDURE DoAppendReal;
  1159.    VAR
  1160.       TObj : TStringClass;
  1161.    BEGIN
  1162.       Writeln('Code:');
  1163.       Writeln('TObj := TStringClass.CreateString([''AReal = '']);');
  1164.       Writeln('TObj.AppendReal(AReal,10,2);');
  1165.       TObj := TStringClass.CreateString(['AReal = ']);
  1166.       TObj.AppendReal(AReal,10,2);
  1167.       Writeln;
  1168.       Writeln('Result:');
  1169.       Writeln(TObj.ZString);
  1170.       TObj.Free;
  1171.    END;
  1172.  
  1173.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1174.  
  1175.    PROCEDURE DoAppendRight;
  1176.    VAR
  1177.       TObj : TStringClass;
  1178.    BEGIN
  1179.       Writeln('Code:');
  1180.       Writeln('TObj := TStringClass.CreateString([AStr]);');
  1181.       Writeln('TObj.AppendRight([APChar],3);');
  1182.       TObj := TStringClass.CreateString([AStr]);
  1183.       TObj.AppendRight([APChar],3);
  1184.       Writeln;
  1185.       Writeln('Result:');
  1186.       Writeln(TObj.ZString);
  1187.       TObj.Free;
  1188.    END;
  1189.  
  1190.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1191.  
  1192.    PROCEDURE DoAppendSIC;
  1193.    VAR
  1194.       TObj : TStringClass;
  1195.    BEGIN
  1196.       Writeln('Code:');
  1197.       Writeln('TObj := TStringClass.CreateString([''Call me '']);');
  1198.       Writeln('TObj.AppendSIC([''Mr Tibbs'']);');
  1199.       TObj := TStringClass.CreateString(['Call me ']);
  1200.       TObj.AppendSIC(['Mr Tibbs']);
  1201.       Writeln;
  1202.       Writeln('Result:');
  1203.       Writeln(TObj.ZString);
  1204.       TObj.Free;
  1205.    END;
  1206.  
  1207.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1208.  
  1209.    PROCEDURE DoAppendTrim;
  1210.    VAR
  1211.       TObj : TStringClass;
  1212.    BEGIN
  1213.       Writeln('Code:');
  1214.       Writeln('TObj := TStringClass.CreateString([''Call me '']);');
  1215.       Writeln('TObj.AppendTrim([''       Mr Tibbs        '']);');
  1216.       TObj := TStringClass.CreateString(['Call me ']);
  1217.       TObj.AppendTrim(['       Mr Tibbs        ']);
  1218.       Writeln;
  1219.       Writeln('Result:');
  1220.       Writeln(TObj.ZString);
  1221.       TObj.Free;
  1222.    END;
  1223.  
  1224.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1225.  
  1226.    PROCEDURE DoAppendWithTab;
  1227.    VAR
  1228.       TObj : TStringClass;
  1229.    BEGIN
  1230.       Writeln('Code:');
  1231.       Writeln('TObj := TStringClass.Create;');
  1232.       Writeln('TObj.AppendWithTab([''First'']);');
  1233.       Writeln('TObj.Append([''Second'']);');
  1234.       TObj := TStringClass.Create;
  1235.       TObj.AppendWithTab(['First']);
  1236.       TObj.Append(['Second']);
  1237.       Writeln;
  1238.       Writeln('Result:');
  1239.       Writeln(TObj.ZString);
  1240.       TObj.Free;
  1241.    END;
  1242.  
  1243.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1244.  
  1245.    PROCEDURE DoNLAppend;
  1246.    VAR
  1247.       TObj : TStringClass;
  1248.    BEGIN
  1249.       Writeln('Code:');
  1250.       Writeln('TObj := TStringClass.CreateString([AStr]);');
  1251.       Writeln('TObj.NLAppend([APChar]);');
  1252.       TObj := TStringClass.CreateString([AStr]);
  1253.       TObj.NLAppend([APChar]);
  1254.       Writeln;
  1255.       Writeln('Result:');
  1256.       Writeln(TObj.ZString);
  1257.       TObj.Free;
  1258.    END;
  1259.  
  1260.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1261.  
  1262.    PROCEDURE DoPrepend;
  1263.    VAR
  1264.       TObj : TStringClass;
  1265.    BEGIN
  1266.       Writeln('Code:');
  1267.       Writeln('TObj := TStringClass.CreateString([AStr]);');
  1268.       Writeln('TObj.Prepend([APChar]);');
  1269.       TObj := TStringClass.CreateString([AStr]);
  1270.       TObj.Prepend([APChar]);
  1271.       Writeln;
  1272.       Writeln('Result:');
  1273.       Writeln(TObj.ZString);
  1274.       TObj.Free;
  1275.    END;
  1276.  
  1277.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1278.  
  1279.    PROCEDURE DoFirstNonSpaceCh;
  1280.    VAR
  1281.       TObj : TStringClass;
  1282.       w : WORD;
  1283.       ACh : CHAR;
  1284.    BEGIN
  1285.       Writeln('Code:');
  1286.       Writeln('TObj := TStringClass.CreateString([''      '',AStr]);');
  1287.       Writeln('w := TObj.FirstNonSpaceCh(ACh);');
  1288.       TObj := TStringClass.CreateString(['      ',AStr]);
  1289.       w := TObj.FirstNonSpaceCh(ACh);
  1290.       Writeln;
  1291.       Writeln('Result:');
  1292.       Writeln(TObj.ZString);
  1293.       Writeln('First non space char at base zero position ',w,' and is a ',ACh,' character');
  1294.       TObj.Free;
  1295.    END;
  1296.  
  1297.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1298.  
  1299.    PROCEDURE DoHasCh;
  1300.    VAR
  1301.       TObj : TStringClass;
  1302.       w : WORD;
  1303.       ACh : CHAR;
  1304.       b : boolean;
  1305.    BEGIN
  1306.       Writeln('Code:');
  1307.       Writeln('ACh := ''c'';');
  1308.       Writeln('TObj := TStringClass.CreateString([AStr]);');
  1309.       Writeln('b := TObj.HasCh(ACh,w);');
  1310.       ACh := 'c';
  1311.       TObj := TStringClass.CreateString([AStr]);
  1312.       b := TObj.HasCh(ACh,w);
  1313.       Writeln;
  1314.       Writeln('Result:');
  1315.       Writeln(TObj.ZString);
  1316.       IF b THEN
  1317.       BEGIN
  1318.          Write('Character ',ACh,' is found within the string');
  1319.          Writeln(' at position ',w);
  1320.       END
  1321.       ELSE
  1322.          Writeln('Character ',ACh,' is NOT found within the string');
  1323.       TObj.Free;
  1324.    END;
  1325.  
  1326.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1327.  
  1328.    PROCEDURE DoIsCh;
  1329.    VAR
  1330.       TObj : TStringClass;
  1331.       w : WORD;
  1332.       ACh : CHAR;
  1333.       b : boolean;
  1334.    BEGIN
  1335.       Writeln('Code:');
  1336.       Writeln('ACh := ''c'';');
  1337.       Writeln('TObj := TStringClass.CreateString([AStr]);');
  1338.       Writeln('b := TObj.IsCh(3,ACh);');
  1339.       ACh := 'c';
  1340.       TObj := TStringClass.CreateString([AStr]);
  1341.       b := TObj.IsCh(3,ACh);
  1342.       Writeln;
  1343.       Writeln('Result:');
  1344.       Writeln(TObj.ZString);
  1345.       IF b THEN
  1346.       BEGIN
  1347.          Writeln('Character ',ACh,' is found at position 3');
  1348.       END
  1349.       ELSE
  1350.          Writeln('Character ',ACh,' is NOT found at position 3');
  1351.       TObj.Free;
  1352.    END;
  1353.  
  1354.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1355.  
  1356.    PROCEDURE DoFromRGB;
  1357.    VAR
  1358.       TObj : TStringClass;
  1359.       C : TColorRef;
  1360.    BEGIN
  1361.       Writeln('Code:');
  1362.       Writeln('TObj := TStringClass.Create;');
  1363.       Writeln('C := RGB(255,255,0);');
  1364.       Writeln('TObj.FromRGB(C);');
  1365.       TObj := TStringClass.Create;
  1366.       C := RGB(255,255,0);
  1367.       TObj.FromRGB(C);
  1368.       Writeln;
  1369.       Writeln('Result:');
  1370.       Writeln(TObj.ZString);
  1371.       TObj.Free;
  1372.    END;
  1373.  
  1374.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1375.  
  1376.    PROCEDURE DoFindCmdLine;
  1377.    VAR
  1378.       TObj : TStringClass;
  1379.    BEGIN
  1380.       Writeln('Code:');
  1381.       Writeln('TObj := TStringClass.Create;');
  1382.       Writeln('TObj.FindCmdLine;');
  1383.       TObj := TStringClass.Create;
  1384.       TObj.FindCmdLine;
  1385.       Writeln;
  1386.       Writeln('Result:');
  1387.       Writeln(TObj.ZString);
  1388.       TObj.Free;
  1389.    END;
  1390.  
  1391.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1392.  
  1393.    PROCEDURE DoFindRelPath;
  1394.    VAR
  1395.       TObj : TStringClass;
  1396.    BEGIN
  1397.       Writeln('Code:');
  1398.       Writeln('TObj := TStringClass.Create;');
  1399.       Writeln('TObj.FindRelPath([''c:\windows''],[''c:\test\data'']);');
  1400.       TObj := TStringClass.Create;
  1401.       TObj.FindRelPath(['c:\windows'],['c:\test\data']);
  1402.       Writeln;
  1403.       Writeln('Result:');
  1404.       Writeln(TObj.ZString);
  1405.       TObj.Free;
  1406.    END;
  1407.  
  1408.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1409.  
  1410.    PROCEDURE DoJustExtension;
  1411.    VAR
  1412.       TObj : TStringClass;
  1413.    BEGIN
  1414.       Writeln('Code:');
  1415.       Writeln('TObj := TStringClass.Create;');
  1416.       Writeln('TObj.JustExtension([APath]);');
  1417.       TObj := TStringClass.Create;
  1418.       TObj.JustExtension([APath]);
  1419.       Writeln;
  1420.       Writeln('Result:');
  1421.       Writeln(TObj.ZString);
  1422.       TObj.Free;
  1423.    END;
  1424.  
  1425.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1426.  
  1427.    PROCEDURE DoJustFileName;
  1428.    VAR
  1429.       TObj : TStringClass;
  1430.    BEGIN
  1431.       Writeln('Code:');
  1432.       Writeln('TObj := TStringClass.Create;');
  1433.       Writeln('TObj.JustFileName([APath]);');
  1434.       TObj := TStringClass.Create;
  1435.       TObj.JustFileName([APath]);
  1436.       Writeln;
  1437.       Writeln('Result:');
  1438.       Writeln(TObj.ZString);
  1439.       TObj.Free;
  1440.    END;
  1441.  
  1442.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1443.  
  1444.    PROCEDURE DoJustName;
  1445.    VAR
  1446.       TObj : TStringClass;
  1447.  
  1448.       { ++++++++++++++++++++++++++++++++++++++++++++++++ }
  1449.  
  1450.       PROCEDURE FromStr(AStr : PChar);
  1451.       BEGIN
  1452.          Writeln('From ...');
  1453.          Writeln('   ',AStr);
  1454.          TObj.JustName([AStr]);
  1455.          Writeln('Name ...');
  1456.          Writeln('   ',TObj.ZString);
  1457.       END;
  1458.  
  1459.       { ++++++++++++++++++++++++++++++++++++++++++++++++ }
  1460.  
  1461.    BEGIN
  1462.       TObj := TStringClass.Create;
  1463.       FromStr('c:\testdata\mainfile.txt');
  1464.       FromStr('testdata\mainfile.txt');
  1465.       FromStr('\mainfile.txt');
  1466.       FromStr('mainfile.txt');
  1467.       FromStr('mainfile');
  1468.       FromStr('*.ext');
  1469.       FromStr('C:\*.*');
  1470.       FromStr('C:\');
  1471.       FromStr('C:\testpath\');
  1472.       TObj.Free;
  1473.    END;
  1474.  
  1475.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1476.  
  1477.    PROCEDURE DoJustDirectory;
  1478.    VAR
  1479.       TObj : TStringClass;
  1480.  
  1481.       { +++++++++++++++++++++++++++++++++++++++++++++ }
  1482.  
  1483.       PROCEDURE FromStr(S : PChar);
  1484.       BEGIN
  1485.          Writeln('From ....');
  1486.          Writeln('   ',S);
  1487.          Writeln('Directory ....');
  1488.          TObj.JustDirectory([S]);
  1489.          Writeln('   ',TObj.ZString);
  1490.       END;
  1491.  
  1492.       { +++++++++++++++++++++++++++++++++++++++++++++ }
  1493.  
  1494.    BEGIN
  1495.       TObj := TStringClass.Create;
  1496.       FromStr('test.txt');
  1497.       FromStr('c:\');
  1498.       FromStr('c:');
  1499.       FromStr('c:\windows');
  1500.       FromStr('c:\windows\system\');
  1501.       FromStr('c:\*.*');
  1502.       FromStr('c:\data.dat');
  1503.       FromStr('c:\main\data');
  1504.       FromStr('c:\main\data.txt');
  1505.       FromStr('*.txt');
  1506.       TObj.Free;
  1507.    END;
  1508.  
  1509.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1510.  
  1511.    PROCEDURE DoReplaceAll;
  1512.    VAR
  1513.       TObj : TStringClass;
  1514.    BEGIN
  1515.       Writeln('Code:');
  1516.       Writeln('TObj := TStringClass.CreateString([AStr,'' '',APChar]);');
  1517.       Writeln('TObj.ReplaceAll([''string''],[''text'']);');
  1518.       TObj := TStringClass.CreateString([AStr,' ',APChar]);
  1519.       TObj.ReplaceAll(['string'],['text']);
  1520.       Writeln;
  1521.       Writeln('Result:');
  1522.       Writeln(TObj.ZString);
  1523.       TObj.Free;
  1524.    END;
  1525.  
  1526.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1527.  
  1528.    PROCEDURE DoDelete;
  1529.    VAR
  1530.       TObj : TStringClass;
  1531.    BEGIN
  1532.       Writeln('Code:');
  1533.       Writeln('TObj := TStringClass.CreateString([AStr]);');
  1534.       Writeln('TObj.Delete(2,3);');
  1535.       TObj := TStringClass.CreateString([AStr]);
  1536.       TObj.Delete(2,3);
  1537.       Writeln;
  1538.       Writeln('Result:');
  1539.       Writeln(TObj.ZString);
  1540.       TObj.Free;
  1541.    END;
  1542.  
  1543.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1544.  
  1545.    PROCEDURE DoDeleteFrom;
  1546.    VAR
  1547.       TObj : TStringClass;
  1548.    BEGIN
  1549.       Writeln('Code:');
  1550.       Writeln('TObj := TStringClass.CreateString([AStr]);');
  1551.       Writeln('TObj.DeleteFrom(2);');
  1552.       TObj := TStringClass.CreateString([AStr]);
  1553.       TObj.DeleteFrom(2);
  1554.       Writeln;
  1555.       Writeln('Result:');
  1556.       Writeln(TObj.ZString);
  1557.       TObj.Free;
  1558.    END;
  1559.  
  1560.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1561.  
  1562.    PROCEDURE DoParseDelimToList;
  1563.    VAR
  1564.       TObj : TStringClass;
  1565.       AList : TObjectContainer;
  1566.  
  1567.       { ++++++++++++++++++++++++++++++++++++++++++++++ }
  1568.  
  1569.       PROCEDURE WrSub(S : TStringClass); FAR;
  1570.       BEGIN
  1571.          IF S.Length = 0 THEN
  1572.             Writeln('<null>')
  1573.          ELSE
  1574.             Writeln(S.ZString);
  1575.       END;
  1576.  
  1577.       { ++++++++++++++++++++++++++++++++++++++++++++++ }
  1578.  
  1579.    BEGIN
  1580.       Writeln('Code:');
  1581.       Writeln('AList := TObjectContainer.Create;');
  1582.       Writeln('AList.Capacity := 100;');
  1583.       Writeln('TObj := TStringClass.CreateString([''xxx,yyy,zzzz,wwww,,qqqq,rrrr'']);');
  1584.       Writeln('TObj.ParseDelimToList('','',delim_None,AList);');
  1585.       Writeln('AList.ForEach(@WrSub);');
  1586.       AList := TObjectContainer.Create;
  1587.       AList.Capacity := 100;
  1588.       TObj := TStringClass.CreateString(['xxx,yyy,zzzz,wwww,,qqqq,rrrr']);
  1589.       TObj.ParseDelimToList(',',delim_None,AList);
  1590.       Writeln;
  1591.       Writeln('Result:');
  1592.       Writeln(TObj.ZString);
  1593.       Writeln('Parsed sub strings ...');
  1594.       AList.ForEach(@WrSub);
  1595.       TObj.Free;
  1596.       AList.Free;
  1597.    END;
  1598.  
  1599.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1600.  
  1601.    PROCEDURE DoParseMultiDelimToList;
  1602.    VAR
  1603.       PartObj,TObj : TStringClass;
  1604.       AList : TObjectContainer;
  1605.       I : LONGINT;
  1606.  
  1607.       { ++++++++++++++++++++++++++++++++++++++++++++++ }
  1608.  
  1609.       PROCEDURE WrSub(S : TStringClass); FAR;
  1610.       BEGIN
  1611.          IF S.Length = 0 THEN
  1612.             Writeln('<null>')
  1613.          ELSE
  1614.             Writeln(S.ZString);
  1615.       END;
  1616.  
  1617.       { ++++++++++++++++++++++++++++++++++++++++++++++ }
  1618.  
  1619.    BEGIN
  1620.       Writeln('Code:');
  1621.       Writeln('AList := TObjectContainer.Create;');
  1622.       Writeln('AList.Capacity := 100;');
  1623.       Writeln('AList.ForEach(@WrSub);');
  1624.       Writeln('TObj := TStringClass.CreateString([''>QFADS 14:30:30 - 14:45:00  95/11/01'']);');
  1625.       Writeln('TObj.ParseMultiDelimToList(['' - '','' '',''>QFADS'','':'',''/''],delim_ExcNull,AList');
  1626.       AList := TObjectContainer.Create;
  1627.       AList.Capacity := 100;
  1628.       TObj := TStringClass.CreateString(['>QFADS 14:30:30 - 14:45:00  95/11/01']);
  1629.       TObj.ParseMultiDelimToList([' - ',' ','>QFADS',':','/'],delim_ExcNull,AList);
  1630.       Writeln;
  1631.       Writeln('Result:');
  1632.       Writeln(TObj.ZString);
  1633.       Writeln('Parsed sub strings ...');
  1634.       AList.ForEach(@WrSub);
  1635.       { another way of doing the above is as follows .... }
  1636.       (*
  1637.       FOR I := 0 TO AList.Count-1 DO
  1638.       BEGIN
  1639.          PartObj := TStringClass(AList.Items[I]);
  1640.          Writeln(PartObj.ZString);
  1641.       END;
  1642.       *)
  1643.       TObj.Free;
  1644.       AList.Free;
  1645.    END;
  1646.  
  1647.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1648.  
  1649.    PROCEDURE DoDirectoryExists;
  1650.    VAR
  1651.       TObj : TStringClass;
  1652.    BEGIN
  1653.       Writeln('Code:');
  1654.       Writeln('TObj := TStringClass.CreateString([APath]);');
  1655.       Writeln('B := TObj.DirectoryExists;');
  1656. {      TObj := TStringClass.CreateString([APath]); }
  1657.       TObj := TStringClass.CreateString(['c:\windows\system\']);
  1658.       Writeln;
  1659.       Writeln('Result:');
  1660.       Writeln(TObj.ZString);
  1661.       Write('Directory ');
  1662.       IF TObj.DirectoryExists THEN
  1663.          Writeln('exists')
  1664.       ELSE
  1665.          Writeln('does not exist');
  1666.       TObj.Free;
  1667.    END;
  1668.  
  1669.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1670.  
  1671.    PROCEDURE DoFindCurrentDir;
  1672.    VAR
  1673.       TObj : TStringClass;
  1674.    BEGIN
  1675.       Writeln('Code:');
  1676.       Writeln('TObj := TStringClass.Create;');
  1677.       Writeln('TObj.FindCurrentDir;');
  1678.       TObj := TStringClass.Create;
  1679.       TObj.FindCurrentDir;
  1680.       Writeln;
  1681.       Writeln('Result:');
  1682.       Writeln(TObj.ZString);
  1683.       TObj.Free;
  1684.    END;
  1685.  
  1686.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1687.  
  1688.    PROCEDURE DoFileExists;
  1689.    VAR
  1690.       TObj : TStringClass;
  1691.    BEGIN
  1692.       Writeln('Code:');
  1693.       Writeln('TObj := TStringClass.CreateString([APath]);');
  1694.       TObj := TStringClass.CreateString([APath]);
  1695.       Writeln;
  1696.       Writeln('Result:');
  1697.       Writeln(TObj.ZString);
  1698.       Write('File ');
  1699.       IF TObj.FileExists THEN
  1700.          Writeln('exists')
  1701.       ELSE
  1702.          Writeln('does not exist');
  1703.       TObj.Free;
  1704.    END;
  1705.  
  1706.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1707.  
  1708.    PROCEDURE DoFileSplit;
  1709.    VAR
  1710.       TObj,DObj,NObj,EObj : TStringClass;
  1711.    BEGIN
  1712.       Writeln('Code:');
  1713.       Writeln('DObj := TStringClass.Create;');
  1714.       Writeln('NObj := TStringClass.Create;');
  1715.       Writeln('EObj := TStringClass.Create;');
  1716.       Writeln('TObj := TStringClass.CreateString([APath]);');
  1717.       Writeln('TObj.FileSplit(DObj,NObj,EObj);');
  1718.       DObj := TStringClass.Create;
  1719.       NObj := TStringClass.Create;
  1720.       EObj := TStringClass.Create;
  1721.       TObj := TStringClass.CreateString([APath]);
  1722.       TObj.FileSplit(DObj,NObj,EObj);
  1723.       Writeln;
  1724.       Writeln('Result:');
  1725.       Writeln(TObj.ZString);
  1726.       Writeln(DObj.ZString);
  1727.       Writeln(NObj.ZString);
  1728.       Writeln(EObj.ZString);
  1729.       TObj.Free;
  1730.       DObj.Free;
  1731.       NObj.Free;
  1732.       EObj.Free;
  1733.    END;
  1734.  
  1735.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1736.  
  1737.    PROCEDURE DoGrep;
  1738.    VAR
  1739.       TObj : TStringClass;
  1740.       AList : TWordContainer;
  1741.       E : LONGINT;
  1742.    BEGIN
  1743.       TObj := TStringClass.CreateString([APath]);
  1744.       Writeln;
  1745.       Writeln('Result:');
  1746.       Writeln(TObj.ZString);
  1747.       Writeln('Grep locations:');
  1748.       AList := TWordContainer.Create;
  1749.       AList.Capacity := 10;
  1750.       IF TObj.Grep(['in'],AList) > 0 THEN
  1751.       BEGIN
  1752.          FOR E := 0 TO AList.Count-1 DO
  1753.             WRITELN('   ',AList.Items[E]);
  1754.       END
  1755.       ELSE
  1756.          Writeln('< none>');
  1757.       AList.RemoveAll;
  1758.       IF TObj.Grep(['s?'],AList) > 0 THEN
  1759.       BEGIN
  1760.          FOR E := 0 TO AList.Count-1 DO
  1761.             WRITELN('   ',AList.Items[E]);
  1762.       END
  1763.       ELSE
  1764.          Writeln('< none>');
  1765.       TObj.Free;
  1766.       AList.Free;
  1767.    END;
  1768.  
  1769.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1770.  
  1771.    PROCEDURE DoAddFilterDesc;
  1772.    VAR
  1773.       TObj : TStringClass;
  1774.    BEGIN
  1775.       Writeln('TObj := TStringClass.Create;');
  1776.       Writeln('TObj.AddFilterDesc([''Pascal source files''],[''PAS'']);');
  1777.       Writeln('TObj.AddFilterDesc([''C++ source files''],[''CPP'']);');
  1778.       Writeln;
  1779.       Writeln('Result : ');
  1780.       Writeln;
  1781.       TObj := TStringClass.Create;
  1782.       TObj.AddFilterDesc(['Pascal source files'],['PAS']);
  1783.       TObj.AddFilterDesc(['C++ source files'],['CPP']);
  1784.       Writeln(TObj.ZString);
  1785.       TObj.Free;
  1786.    END;
  1787.  
  1788.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1789.  
  1790.    PROCEDURE DoAddBackSlash;
  1791.    VAR
  1792.       TObj : TStringClass;
  1793.    BEGIN
  1794.       Writeln('TObj := TStringClass.CreateString([APath]);');
  1795.       Writeln('TObj.AddBackSlash;');
  1796.       Writeln;
  1797.       Writeln('Result : ');
  1798.       Writeln;
  1799.       TObj := TStringClass.CreateString([APath]);
  1800.       TObj.AddBackSlash;
  1801.       Writeln(TObj.ZString);
  1802.       TObj.Free;
  1803.    END;
  1804.  
  1805.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1806.  
  1807.    PROCEDURE DoAnsiCompareStr;
  1808.    VAR
  1809.       TObj : TStringClass;
  1810.       C : INTEGER;
  1811.    BEGIN
  1812.       Writeln('TObj := TStringClass.CreateString([AStr]);');
  1813.       Writeln('TObj.ToUpper;');
  1814.       Writeln('C := TObj.AnsiCompareStr(AStr);');
  1815.       Writeln;
  1816.       Writeln('Result : ');
  1817.       Writeln;
  1818.       TObj := TStringClass.CreateString([AStr]);
  1819.       TObj.ToUpper;
  1820.       C := TObj.AnsiCompareStr(AStr);
  1821.       Writeln(TObj.ZString,' : ',AStr,' : ',C);
  1822.       TObj.Free;
  1823.    END;
  1824.  
  1825.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1826.  
  1827.    PROCEDURE DoAnsiCompareText;
  1828.    VAR
  1829.       TObj : TStringClass;
  1830.       C : INTEGER;
  1831.    BEGIN
  1832.       Writeln('TObj := TStringClass.CreateString([AStr]);');
  1833.       Writeln('TObj.ToUpper;');
  1834.       Writeln('C := TObj.AnsiCompareText(AStr);');
  1835.       Writeln;
  1836.       Writeln('Result : ');
  1837.       Writeln;
  1838.       TObj := TStringClass.CreateString([AStr]);
  1839.       TObj.ToUpper;
  1840.       C := TObj.AnsiCompareText(AStr);
  1841.       Writeln(TObj.ZString,' : ',AStr,' : ',C);
  1842.       TObj.Free;
  1843.    END;
  1844.  
  1845.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1846.  
  1847.    PROCEDURE DoAnsiLowerCase;
  1848.    VAR
  1849.       TObj : TStringClass;
  1850.       C : INTEGER;
  1851.    BEGIN
  1852.       Writeln('TObj := TStringClass.Create;');
  1853.       Writeln('TObj.AnsiLowerCase;');
  1854.       Writeln;
  1855.       Writeln('Result : ');
  1856.       Writeln;
  1857.       TObj := TStringClass.Create;
  1858.       TObj.AnsiLowerCase(AStr);
  1859.       Writeln(TObj.ZString);
  1860.       TObj.Free;
  1861.    END;
  1862.  
  1863.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1864.  
  1865.    PROCEDURE DoAnsiUpperCase;
  1866.    VAR
  1867.       TObj : TStringClass;
  1868.       C : INTEGER;
  1869.    BEGIN
  1870.       Writeln('TObj := TStringClass.Create;');
  1871.       Writeln('TObj.AnsiUpperCase;');
  1872.       Writeln;
  1873.       Writeln('Result : ');
  1874.       Writeln;
  1875.       TObj := TStringClass.Create;
  1876.       TObj.AnsiUpperCase(AStr);
  1877.       Writeln(TObj.ZString);
  1878.       TObj.Free;
  1879.    END;
  1880.  
  1881.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1882.  
  1883.    PROCEDURE DoAppendStr;
  1884.    VAR
  1885.       TObj : TStringClass;
  1886.       C : INTEGER;
  1887.    BEGIN
  1888.       Writeln('TObj := TStringClass.CreateString([APChar]);');
  1889.       Writeln('TObj.AppendStr(AStr);');
  1890.       Writeln;
  1891.       Writeln('Result : ');
  1892.       Writeln;
  1893.       TObj := TStringClass.CreateString([APChar]);
  1894.       TObj.AppendStr(AStr);
  1895.       Writeln(TObj.ZString);
  1896.       TObj.Free;
  1897.    END;
  1898.  
  1899.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1900.  
  1901.    PROCEDURE DoParsePosToList;
  1902.    CONST
  1903.       IPos : ARRAY[0..2,0..1] OF INTEGER = ((0,4),(6,3),(10,2));
  1904.       TestStr = 'This is a test for ParsePosToList';
  1905.    VAR
  1906.       Alist : TObjectContainer;
  1907.       TObj : TStringClass;
  1908.  
  1909.       { +++++++++++++++++++++++++++++++++++++++++ }
  1910.  
  1911.       PROCEDURE WritePart(S : TStringClass); FAR;
  1912.       BEGIN
  1913.          Writeln('   ',S.ZString);
  1914.       END;
  1915.  
  1916.       { +++++++++++++++++++++++++++++++++++++++++ }
  1917.  
  1918.    BEGIN
  1919.  
  1920.       AList := TObjectContainer.Create;
  1921.       Writeln('CONST');
  1922.       Writeln('   IPos : ARRAY[0..2,0..1] OF INTEGER = ((0,4),(6,3),(10,2));');
  1923.       Writeln('   TestStr = ''This is a test for ParsePosToList''');
  1924.       Writeln('   TObj := TStringClass.CreateString([TestStr]);');
  1925.       Writeln('   TObj.ParsePosToList(IPos,3,AList);');
  1926.       TObj := TStringClass.CreateString([TestStr]);
  1927.       TObj.ParsePosToList(IPos,3,AList);
  1928.       Writeln('Results ....');
  1929.       AList.ForEach(@WritePart);
  1930.       AList.Free;
  1931.       TObj.Free;
  1932.  
  1933.    END;
  1934.  
  1935.    { +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ }
  1936.  
  1937. BEGIN
  1938.    ANullStrObj := TStringClass.Create;
  1939.    AStrObj := TStringClass.CreateString(['TStringClass string']);
  1940.    OutConsole.ClrScr;
  1941.    CASE fid OF
  1942.       id_Create :
  1943.          DoCreate;
  1944.       id_CreateSize :
  1945.          DoCreateSize;
  1946.       id_CreateString :
  1947.          DoCreateString;
  1948.       id_CreateStringNL :
  1949.          DoCreateStringNL;
  1950.       id_CreateBoolean :
  1951.          DoCreateBoolean;
  1952.       id_Destroy :
  1953.          DoDestroy;
  1954.       id_Copy :
  1955.          DoCopy;
  1956.       id_CopyFrom :
  1957.          DoCopyFrom;
  1958.       id_Clear :
  1959.          DoClear;
  1960.       id_Empty :
  1961.          DoEmpty;
  1962.       id_Assign :
  1963.          DoAssign;
  1964.       id_AssignFrom :
  1965.          DoAssignFrom;
  1966.       id_AssignLen :
  1967.          DoAssignLen;
  1968.       id_AssignMid :
  1969.          DoAssignMid;
  1970.       id_AssignNL :
  1971.          DoAssignNL;
  1972.       id_AssignPad :
  1973.          DoAssignPad;
  1974.       id_AssignRight :
  1975.          DoAssignRight;
  1976.       id_AssignTrim :
  1977.          DoAssignTrim;
  1978.       id_Append :
  1979.          DoAppend;
  1980.       id_AppendBoolean :
  1981.          DoAppendBoolean;
  1982.       id_AppendByte :
  1983.          DoAppendByte;
  1984.       id_AppendCh :
  1985.          DoAppendCh;
  1986.       id_AppendDIC :
  1987.          DoAppendDIC;
  1988.       id_AppendDouble :
  1989.          DoAppendDouble;
  1990.       id_AppendDoubleTrim :
  1991.          DoAppendDoubleTrim;
  1992.       id_AppendExt :
  1993.          DoAppendExt;
  1994.       id_AppendExtTrim :
  1995.          DoAppendExtTrim;
  1996.       id_AppendLen :
  1997.          DoAppendLen;
  1998.       id_AppendLong :
  1999.          DoAppendLong;
  2000.       id_AppendMid :
  2001.          DoAppendMid;
  2002.       id_AppendNL :
  2003.          DoAppendNL;
  2004.       id_AppendPad :
  2005.          DoAppendPad;
  2006.       id_AppendPtr :
  2007.          DoAppendPtr;
  2008.       id_AppendReal :
  2009.          DoAppendReal;
  2010.       id_AppendRight :
  2011.          DoAppendRight;
  2012.       id_AppendSIC :
  2013.          DoAppendSIC;
  2014.       id_AppendTrim :
  2015.          DoAppendTrim;
  2016.       id_AppendWithTab :
  2017.          DoAppendWithTab;
  2018.       id_NLAppend :
  2019.          DoNLAppend;
  2020.       id_Prepend :
  2021.          DoPrepend;
  2022.       id_FirstNonSpaceCh :
  2023.           DoFirstNonSpaceCh;
  2024.       id_HasCh :
  2025.          DoHasCh;
  2026.       id_isCh :
  2027.          DoIsCh;
  2028.           (*
  2029.       id_IsFirstCh = 44;
  2030.       id_IsLastCh = 45;
  2031.       id_LastNonSpaceCh = 46;
  2032.       id_RemoveLastCh = 47;
  2033.       id_SetCh = 48;
  2034.       id_FromBoolean = 49;
  2035.       id_FromByte = 50;
  2036.       id_FromChar = 51;
  2037.       id_FromDouble = 52;
  2038.       id_FromDoubleTrim = 53;
  2039.       id_FromExt = 54;
  2040.       id_FromExtTrim  = 55;
  2041.       id_FromLong = 56;
  2042.       id_FromPtr = 57;
  2043.       id_FromReal = 58;
  2044.       id_FromRealTrim = 59;
  2045.       *)
  2046.       id_FromRGB :
  2047.          DoFromRGB;
  2048.          (*
  2049.       id_HexFromByte = 61;
  2050.       id_HexFromLong = 62;
  2051.       id_HexFromPtr = 63;
  2052.       id_HexFromWord = 64;
  2053.       id_ToBoolean = 65;
  2054.       id_ToByte = 66;
  2055.       id_ToChar = 67;
  2056.       id_ToDouble = 68;
  2057.       id_ToExt = 69;
  2058.       id_ToInteger = 70;
  2059.       id_ToLong = 71;
  2060.       id_ToReal = 72;
  2061.       id_ToRGB = 73;
  2062.       id_ToWord = 74;
  2063.       *)
  2064.       id_AppendStr :
  2065.          DoAppendStr;
  2066.          (*
  2067.       id_UpperCase = 76;
  2068.       id_LowerCase = 77;
  2069.       id_CompareStr = 78;
  2070.       id_CompareText = 79;
  2071.       *)
  2072.       id_AnsiUpperCase :
  2073.          DoAnsiUpperCase;
  2074.       id_AnsiLowerCase :
  2075.          DoAnsiLowerCase;
  2076.       id_AnsiCompareStr :
  2077.          DoAnsiCompareStr;
  2078.       id_AnsiCompareText :
  2079.          DoAnsiCompareText;
  2080.       (*
  2081.       id_IsValidIdent = 84;
  2082.       id_IntToStr = 85;
  2083.       id_IntToHex = 86;
  2084.       id_StrToInt = 87;
  2085.       id_StrToIntDef = 88;
  2086.       id_LoadStr = 89;
  2087.       id_FmtLoadStr = 90;
  2088.       id_Format = 91;
  2089.       id_FloatToStr = 92;
  2090.       id_FloatToStrF = 93;
  2091.       id_FormatFloat = 94;
  2092.       id_StrToFloat = 95;
  2093.       id_StrCat = 96;
  2094.       id_StrComp = 97;
  2095.       id_StrCopy = 98;
  2096.       id_StrECopy = 99;
  2097.       id_StrEnd = 100;
  2098.       id_StrIComp = 101;
  2099.       id_StrLCat = 102;
  2100.       id_StrLIComp = 103;
  2101.       id_StrLComp = 104;
  2102.       id_StrLCopy = 105;
  2103.       id_StrLen = 106;
  2104.       id_StrLower = 107;
  2105.       id_StrMove = 108;
  2106.       id_StrPas = 109;
  2107.       id_StrPCopy = 110;
  2108.       id_StrPos = 111;
  2109.       id_StrRScan = 112;
  2110.       id_StrScan = 113;
  2111.       id_StrUpper = 114;
  2112.       id_Compare = 115;
  2113.       id_CompareI = 116;
  2114.       id_CompareL = 117;
  2115.       id_CompareLI = 118;
  2116.       id_CompareLong = 119;
  2117.       id_CompareDouble = 120;
  2118.       id_CompareExt = 121;
  2119.       id_IsSame = 122;
  2120.       id_IsSameI = 122;
  2121.       id_isSameL = 123;
  2122.       id_IsSameLI = 124;
  2123.       id_Includes = 125;
  2124.       id_Within = 126;
  2125.       *)
  2126.       id_Delete :
  2127.          DoDelete;
  2128.       id_DeleteFrom :
  2129.          DoDeleteFrom;
  2130.       (*
  2131.       id_Insert = 128;
  2132.       id_InsertL = 129;
  2133.       id_PadCentre = 130;
  2134.       id_PadEnd = 131;
  2135.       id_PadFront = 132;
  2136.       id_RemoveDIC = 133;
  2137.       id_RemoveSIC = 134;
  2138.       id_Trim = 135;
  2139.       id_TrimEnd = 136;
  2140.       id_TrimFront = 137;
  2141.       id_TrimZero = 138;
  2142.       *)
  2143.       id_FindCmdLine :
  2144.          DoFindCmdLine;
  2145.       (*
  2146.       id_FindCmdLineAndParse = 140;
  2147.       id_FindCmdLineParam = 141;
  2148.       id_AppendStringRes = 142;
  2149.       id_LoadStringRes = 143;
  2150.       id_ReadIniKeyword = 144;
  2151.       id_WriteIniKeyword = 145;
  2152.       id_FindIniSectionKeywords = 146;
  2153.       *)
  2154.       id_AddBackSlash :
  2155.          DoAddBackSlash;
  2156.          (*
  2157.       id_BuildPathName = 148;
  2158.       id_DefaultExtension = 149;
  2159.       id_ExpandFileName = 150;
  2160.       *)
  2161.       id_addFilterDesc :
  2162.          DoAddFilterDesc;
  2163.       id_FindRelPath :
  2164.          DoFindRelPath;
  2165.       (*
  2166.       id_ForceExtension = 151;
  2167.       id_HasBackSlash = 152;
  2168.       id_HasDrive = 153;
  2169.       id_HasExtension = 154;
  2170.       id_HasFileName = 155;
  2171.       id_HasDirectory = 156;
  2172.       *)
  2173.       id_FindCurrentDir :
  2174.          DoFindCurrentDir;
  2175.       id_DirectoryExists :
  2176.          DoDirectoryExists;
  2177.       (*
  2178.       id_DriveExists = 158;
  2179.       *)
  2180.       id_FileExists :
  2181.          DoFileExists;
  2182.       id_FileSplit :
  2183.          DoFileSplit;
  2184.       id_JustExtension :
  2185.          DoJustExtension;
  2186.       id_JustFileName :
  2187.          DoJustFileName;
  2188.       id_JustName :
  2189.          DoJustName;
  2190.       id_JustDirectory :
  2191.          DoJustDirectory;
  2192.          (*
  2193.       id_SetCurDir = 163;
  2194.       id_ChCount = 164;
  2195.       id_FindBetween2Ch = 165;
  2196.       id_FindFirst = 166;
  2197.       id_FindFirstCh = 167;
  2198.       id_FindLast = 168;
  2199.       id_FindLastCh = 169;
  2200.       id_FindNext = 170;
  2201.       id_FindNextCh = 171;
  2202.       id_FindPrev = 172;
  2203.       id_FindPrevCh = 173;
  2204.       id_SubStrCount = 174;
  2205.       id_FirstCharToUpper = 175;
  2206.       id_IsAlphaNumeric = 176;
  2207.       id_ToLower = 177;
  2208.       id_ToUpper = 178;
  2209.       *)
  2210.       id_ReplaceAll :
  2211.          DoReplaceAll;
  2212.       (*
  2213.       id_ReplaceFirst = 180;
  2214.       id_ReplaceLast = 181;
  2215.       id_ReplaceChAll = 182;
  2216.       id_ReplaceChFirst = 183;
  2217.       id_ReplaceChLast = 184;
  2218.       id_FirstParseDelim = 185;
  2219.       id_NextParseDelim = 186;
  2220.       id_ParseDelimCount = 187;
  2221.       *)
  2222.       id_ParseDelimToList :
  2223.          DoParseDelimToList;
  2224.       id_ParseMultiDelimToList :
  2225.          DoParseMultiDelimToList;
  2226.       id_ParsePosToList :
  2227.          DoParsePosToList;
  2228.       id_grep :
  2229.          DoGrep;
  2230.    END;
  2231.    { scroll to top }
  2232.    OutConsole.ScrollTo(0,0);
  2233. END;
  2234.  
  2235. { :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: }
  2236.  
  2237.  
  2238. end.
  2239.